COMMENT ⊗   VALID 00008 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00002 00002	ENTRY SWITCHCHAN,IFVCOUTPUT,IFVCURSORMAP,IFVCMAP,GETIFVCMAP,ZOOM_PAN,
C00009 00003	INTERNAL PROCEDURE ZOOM_PAN(INTEGER CHAN, ZOOMFACTOR, ELEMENT, LINE, CONTROL_BITS)
C00010 00004	! Cursor read back and control routines
C00015 00005	INTERNAL PROCEDURE DIGITIZE(INTEGER  THRESHOLD, SHIFT, NFRAMES, CONTROL_BITS, DATASET(0))
C00017 00006	! Image Analyzer Card funtions
C00021 00007	! IMAGE PROCESSOR CARD ROUTINES
C00024 00008	END "CRDFNC"
C00026 ENDMK
C⊗;
ENTRY SWITCHCHAN,IFVCOUTPUT,IFVCURSORMAP,IFVCMAP,GETIFVCMAP,ZOOM_PAN,
	GINQUIRE_CURSOR, GSHOW_CURSOR,
	GABS_SET_CURSOR,GREL_SET_CURSOR,DIGITIZE,MAXMIN,GDISTRIBUTION,
	GHISTOGRAM,
	IPCMAP,IPCSWITCH,IPCCONTROL,IPCCTRLMODE,IPCWRITE;
DEFINE !="COMMENT";
DEFINE TO="STEP 1 UNTIL";
BEGIN "CRDFNC"
REQUIRE "GRNDEF[HDR,HE]" SOURCE_FILE;
REQUIRE "GRNHDR[HDR,HE]" SOURCE_FILE;
! Routines to control image function video control;
INTERNAL PROCEDURE SWITCHCHAN(INTEGER CARD, SOURCEA, SOURCEB, SOURCEC);
  BEGIN "Switch"
  Comment This routine will switch the channel to the specified table on the 
	  specified card (0 or 1);
  
  GRNINS(SPD LOR READBACK);		 ! Selecting READBACK as a peripheral;
					 ! devices  Read allows access to the;
					 ! Peripheral Control bits to specify;
					 ! which of 2 cards is to be used;
  IF CARD = 1 THEN  GRNINS(LPR LOR VIDMAP1) ELSE GRNINS(LPR LOR VIDMAP0);
  GRNINS(SPD LOR IFNCVID);  ! Selects the Image Video Function;
  
! Switch specified channel to the  specified lookup table;
! NOTE that chan must be between 0-3, and tableno is between 0-2;
  GRNINS(LPR4 LOR (SOURCEC LSH 4) LOR (SOURCEB LSH 2) LOR SOURCEA);
  END "Switch";

INTERNAL PROCEDURE IFVCOUTPUT(INTEGER CARD, BYPASSMAP, INVERTMAP, CLAMPMAP, OVERLAYMAP);
  BEGIN "IFVCOUTPUT"
  ! This routine controls the output of the Image Function Video Card;
    GRNINS(SPD LOR READBACK);
    IF CARD = 1 THEN GRNINS(LPR LOR VIDMAP1) ELSE GRNINS(LPR LOR VIDMAP0);
    GRNINS(SPD LOR IFNCVID);  ! Selects the Image Video Function;
    GRNINS(LPR5 LOR (CLAMPMAP LSH 6) LOR (INVERTMAP LSH 3) LOR BYPASSMAP);
    GRNINS(LPR1 LOR (OVERLAYMAP LSH 4));
  END "IFVCOUTPUT";

INTERNAL PROCEDURE IFVCURSORMAP(INTEGER CARD, BYPASSMAP, INVERTMAP, CLAMPMAP, OVERLAYMAP);
  BEGIN "IFVCOUTPUT"
  ! This routine controls the output of the Image Function Video Card;
  ! The maps indicate the effects of the lookup tables on the card   ;
  ! Each of the three tables is controled by a bit in the map	     ;
  ! If the bit is on the option is selected. eg. if the BYPASSMAP is ;
  ! '6 then lookup tables A and C will be bypassed		     ;

    GRNINS(SPD LOR READBACK);
    IF CARD = 1 THEN GRNINS(LPR LOR VIDMAP1) ELSE GRNINS(LPR LOR VIDMAP0);
    GRNINS(SPD LOR IFNCVID);  ! Selects the Image Video Function;
    GRNINS(LPR5 LOR (CLAMPMAP LSH 6) LOR (INVERTMAP LSH 3) LOR BYPASSMAP);
    GRNINS(LPR1 LOR OVERLAYMAP);
    GRNINS(LPR2 LOR OVERLAYMAP);
    GRNINS(LPR3 LOR OVERLAYMAP);
  END "IFVCOUTPUT";


INTERNAL PROCEDURE  IFVCMAP(INTEGER CARD, TABLENO; INTEGER ARRAY MAP; 
				INTEGER ADR(0), COUNT(256));
  BEGIN "IFVCMAP"
  INTEGER I;
  GRNINS(SPD LOR READBACK);		 ! Selecting READBACK as a peripheral;
					 ! devices  Read allows access to the;
					 ! Peripheral Control bits to specify;
					 ! which of 2 cards is to be used;
  IF CARD = 1 THEN  GRNINS(LPR LOR VIDMAP1) ELSE GRNINS(LPR LOR VIDMAP0);
  GRNINS(SPD LOR IFNCVID);  ! Selects the Image Video Function;

! Select lookup table and address to write into. If table no is 3 all lookup;
! tables are written into simultaneously;
  GRNINS(LPA LOR ((TABLENO MOD 4) LSH 10) LOR (ADR MOD 256));

! Load map into lookup tables;
  FOR I ← 0 TO COUNT-1 DO GRNINS(LPD LOR MAP[I]);

  END "IFVCMAP";


INTERNAL PROCEDURE GETIFVCMAP(INTEGER CARD,TABLENO; INTEGER ARRAY MAP; 
			INTEGER ADR(0),COUNT(256));
  BEGIN "GETIFVCMAP"

  GRNINS(SPD LOR READBACK);		 ! Selecting READBACK as a peripheral;
					 ! devices  Read allows access to the;
					 ! Peripheral Control bits to specify;
					 ! which of 2 cards is to be used;
  IF CARD = 1 THEN  GRNINS(LPR LOR VIDMAP1) ELSE GRNINS(LPR LOR VIDMAP0);
  GRNINS(SPD LOR IFNCVID);  ! Selects the Image Video Function;

! Select lookup table and address to write into. If table no is 3 all lookup;
! tables are written into simultaneously;
  GRNINS(LPA LOR ((TABLENO MOD 4) LSH 10) LOR (ADR MOD 256));

! Read back data into Array;
  GRNIN(LOCATION(MAP[ARRINFO(MAP,1)]), COUNT);
  END "GETIFVCMAP";
INTERNAL PROCEDURE ZOOM_PAN(INTEGER CHAN, ZOOMFACTOR, ELEMENT, LINE, CONTROL_BITS);
  BEGIN "ZOOM_PAN"
    GRNINS(SPD LOR READBACK);
    GRNINS(LPR LOR ('1 LSH CHAN));
    GRNINS(SPD LOR ZOOM);
    GRNINS(LPA);
    GRNINS(LPD LOR ELEMENT);
    GRNINS(LPD LOR LINE);
    GRNINS(LPR LOR ENAZOOM LOR CONTROL_BITS LOR (ZOOMFACTOR MOD 4));
  END "ZOOM_PAN";

! Cursor read back and control routines;
INTERNAL PROCEDURE GINQUIRE_CURSOR(INTEGER CURSNO; REFERENCE INTEGER ELEMENT, LINE;
			 REFERENCE BOOLEAN FUNA, FUNB, ENTERFLAG);
  BEGIN "GINQUIRE_CURSOR"
! This routine returns the current line, element and status of the flags for the ;
! specified cursor;
    INTEGER ARRAY CURSORINFO[1:2];	! Storage for element and line registers;

    GRNINS(SPD LOR CURSOR);
    GRNINS(LPA LOR (((CURSNO - 1) MOD 4) LSH 1));	
    GRNIN(LOCATION(CURSORINFO[1]), 2);	! Read back element and line register;
					! from DR11B;
    IF CURSORINFO[1] LAND ENTERBIT = 0 THEN ENTERFLAG ← FALSE ELSE ENTERFLAG ← TRUE;
    IF CURSORINFO[1] LAND F1BIT	= 0 THEN FUNB ← FALSE ELSE FUNB ← TRUE;
    IF CURSORINFO[1] LAND F2BIT = 0 THEN FUNA ← FALSE ELSE FUNA ← TRUE;
    ELEMENT ← CURSORINFO[1] LAND '1777;
    LINE ← CURSORINFO[2] LAND '1777;
  END "GINQUIRE_CURSOR";

INTERNAL PROCEDURE GABS_SET_CURSOR(INTEGER CURSNO, ELEMENT, LINE);
 ! Move the cursor tho the given position;
 ! ELEMENT and LINE are screen coordiates;
  BEGIN "GSET_CURSOR_ABS"
    GRNINS(SPD LOR CURSOR);				! Select cursor device;
    GRNINS(LPA LOR (((CURSNO - 1) MOD 4) LSH 1));	! Select one of the cursors;
    GRNINS(LPD LOR ABSOLUTELY LOR ELEMENT);		! Specify new element;
    GRNINS(LPD LOR ABSOLUTELY LOR LINE);		! and new line coordinates;
  END "GSET_CURSOR_ABS";

INTERNAL PROCEDURE GREL_SET_CURSOR(INTEGER CURSNO, DX, DY);
 ! Move cursor relative to current position by given displacements (dx, dy);
 
  BEGIN "GSET_CURSOR_REL"
    GRNINS(SPD LOR CURSOR);				! Select curosr device;
    GRNINS(LPA LOR (((CURSNO - 1) MOD 4) LSH 1));	! and one of the 4 cursors;
    GRNINS(LPD LOR RELATIVELY LOR DX);			! Specify displacement from;
    GRNINS(LPD LOR RELATIVELY LOR DY);			! old position;
  END "GSET_CURSOR_REL";

INTERNAL PROCEDURE GSHOW_CURSOR(INTEGER VISBITS, BLINKBITS);
 ! Will turn the grinnell cursors on or off and cause them to blink;
 ! The low order bits in  VISBITS and BLINKBITS correspond to one of the cursors;
 ! If the bit is 1 in VISBITS then the corresponding cursor will be visible, ;
 ! likewise in BLINKBITS. Note a cursor must be visible to see the blinking effect;
 ! For example if VISBITS = 9 and BLINKBITS = 8 then cursor 1 and 4 would be;
 ! made visible with cursor four blinking. Note that this routine will alter;
 ! the previous states of the cursors. ;
 ! The following bits have been defined in GRNDEF[HDR,HE]:
 ! 	QCURSALL = 17	all four cursors;
 ! 	QCURS1 = 1	Cursor 1	(also QCURS2,3,4 are defined);
  BEGIN "GSHOW_CURSOR"
    GRNINS(SPD LOR CURSOR);				! Select cursor device;
    GRNINS(LPR LOR (BLINKBITS LSH 4) LOR VISBITS);	! Select cursors to be 
							! visible and blinking;
  END "GSHOW_CURSOR";

INTERNAL PROCEDURE DIGITIZE(INTEGER  THRESHOLD, SHIFT, NFRAMES, CONTROL_BITS, DATASET(0));
  BEGIN "DIGITIZE"
    
  ! Digitizer writes into memory channels 2,3 which must be enabled;
    GRNINS(LDC LOR '14); GRNINS(LSM LOR '377);
    GRNINS(SPD LOR READBACK);		! Digitizer is selected by loading PCR;
    GRNINS(LPR LOR '1);			! bit 0 and selecting periphereal device;
    GRNINS(SPD LOR DIGITIZER);		! bit corresponding to the digitizer;

  ! Also specify threshold and number of bits data is to be shifted, and which data
      arithmetic is done with;
    GRNINS(LPR LOR (DATASET LSH 10) LOR (THRESHOLD LSH 4) LOR SHIFT);
  ! Set continuity bit, arithmetic mode and threshhold mode and number of;
  ! frames to be read in if not in continuous mode;
    GRNINS(LPD LOR CONTROL_BITS LOR NFRAMES);
  END "DIGITIZE";

! Image Analyzer Card funtions;

INTERNAL PROCEDURE GDISTRIBUTION(INTEGER SOURCE; REFERENCE INTEGER ARRAY COUNTS;
	INTEGER STARTVAL,NVALS, READBACKMODE, HISTOGRAMMODE);
  BEGIN "GDISTRIBUTION"
    GRNINS(SPD LOR ANALYZER);
    GRNINS(LPR4 LOR (SOURCE MOD 5));
    GRNINS(LPA LOR READBACKMODE LOR STARTVAL);
    GRNINS(LPR5 LOR HISTOGRAMMODE);
    GRNINS(LPD);
    GRNIN(LOCATION(COUNTS[ARRINFO(COUNTS,1)]), NVALS);
    
 END "GDISTRIBUTION";  

INTERNAL PROCEDURE GHISTOGRAM(INTEGER SOURCE; REFERENCE INTEGER ARRAY COUNTS);
  BEGIN "GHISTOGRAM"
    INTEGER ARRAY COUNT[0:255], COUNTH[0:255];
    INTEGER I,J;
    GDISTRIBUTION(SOURCE,COUNT,0,256,LSBITS,NOHISTOGRAM);
    GDISTRIBUTION(SOURCE,COUNTH,0,256,MSBITS,NOHISTOGRAM);
    COMMENT Take 16 MSB's, pick out top two bits, and or them into LSBs.;
    FOR I ← 0 STEP 1 UNTIL 255 DO
	COUNT[I] ← COUNT[I] LOR ((COUNTH[I] LAND '140000) LSH 2);
    J←ARRINFO(COUNTS,1);
    FOR I ← 0 STEP 1 UNTIL 255 DO
	BEGIN
	    COUNTS[J]←COUNT[I];
	    J←J+1
	END;
  END "GHISTOGRAM";
    

INTERNAL PROCEDURE MAXMIN(INTEGER SOURCE; REFERENCE INTEGER MAXIMUM, MINIMUM);
  BEGIN "MAXMIN"
COMMENT If the max/min logic is busted, just read back the histogram and manually
	find the maximum and minimum.;
IFC MXMNBUSTED THENC
    INTEGER ARRAY COUNTS[0:255];
    INTEGER I;
    BOOLEAN GOTIT;
    GHISTOGRAM(SOURCE,COUNTS);

    GOTIT←FALSE; I←0;
    WHILE NOT(GOTIT) DO
	BEGIN
	    GOTIT←COUNTS[I] ≠ 0;
	    I←I+1
	END;
    MINIMUM←I-1;

    GOTIT←FALSE; I←255;
    WHILE NOT(GOTIT) DO
	BEGIN
	    GOTIT←COUNTS[I] ≠ 0;
	    I←I-1
	END;
    MAXIMUM←I+1
ELSEC
    INTEGER ARRAY EXTREMES[1:2];
    GRNINS(SPD LOR ANALYZER);		! Select Image Analyzer Card;
    GRNINS(LPR4 LOR (SOURCE MOD 5));	! Switch input to given source;
    GRNINS(LPD);			! Initialize analyzer memories and reg;
    GRNINS(LPA LOR GETMIN);		! Set readback mode to minimum;
    GRNIN(LOCATION(EXTREMES[1]),2);	! Read back the minimum and maximum;
    MINIMUM ← EXTREMES[1]; 			
    MAXIMUM ← EXTREMES[2];
ENDC
  END "MAXMIN";

! IMAGE PROCESSOR CARD ROUTINES;
INTERNAL PROCEDURE IPCMAP(INTEGER TABLE_ENABLES; INTEGER ARRAY MAP; INTEGER COUNT,
		 STARTADR (0));
  BEGIN "IPCMAP"
    INTEGER I;
    GRNINS(SPD LOR PROCESSOR);
    GRNINS(LPR1 LOR TABLE_ENABLES);
    GRNINS(LPA LOR STARTADR);
    FOR I ← 0 TO COUNT-1 DO GRNINS(LPD LOR MAP[I]);
  END "IPCMAP";

INTERNAL PROCEDURE GETIPCMAP(INTEGER MEMORY; INTEGER ARRAY MAP);
  BEGIN "GETIPCMAP"
    INTEGER I;
    GRNINS(SPD LOR PROCESSOR);
    GRNINS(LPR1 LOR (1 LSH MEMORY));
    GRNINS(LPA LOR 0);
    GRNINS(RPD);
    GRNIN(LOCATION(MAP[ARRINFO(MAP,1)]), 256);
  END "GETIPCMAP";

INTERNAL PROCEDURE IPCSWITCH(INTEGER SOURCE0, SOURCE1, SOURCE2, SOURCE3, AUXILIARY);
  BEGIN "IPCSWITCH"
    GRNINS(SPD LOR PROCESSOR);
    GRNINS(LPR4 LOR (AUXILIARY LSH 8) LOR (SOURCE3 LSH 6) LOR (SOURCE2 LSH 4)
	        LOR (SOURCE1 LSH 2) LOR SOURCE0);
  END "IPCSWITCH";

INTERNAL PROCEDURE IPCCONTROL(INTEGER REGISTER, CONTROL_BITS);

  BEGIN "IPCCONTROL"
    GRNINS(SPD LOR PROCESSOR);
    IF REGISTER = 6 OR REGISTER = 7 THEN 
	GRNINS(LPR LOR (REGISTER LSH 9) LOR CONTROL_BITS);
  END "IPCCONTROL";

INTERNAL PROCEDURE IPCCTRLMODE(INTEGER CONTROL_BITS);
  BEGIN "IPCCTRLMODE"
    GRNINS(SPD LOR PROCESSOR);
    GRNINS(LPR5 LOR CONTROL_BITS);
  END "IPCCTRLMODE";

INTERNAL PROCEDURE IPCWRITE(INTEGER CHAN_ENABLES, WRITEMODE);
  BEGIN "IPCWRITE"
    GRNINS(LDC LOR CHAN_ENABLES);
    GRNINS(SPD LOR PROCESSOR);
    GRNINS(LPR LOR WRITEMODE);
  END "IPCWRITE";
END "CRDFNC"